# 使用logistic回归识别猫
import numpy as np
import matplotlib.pyplot as plt
import h5py
from numpy.core.arrayprint import printoptions
import scipy
from PIL import Image
from scipy import ndimage
from lr_utils import load_dataset

# 加载数据(cat/non-cat)=============================================================================================
train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()

# Example of a picture
index = 5
# 处理图像
plt.imshow(train_set_x_orig[index])
print ("y = " + str(train_set_y[:, index]) + ", it's a '" + classes[np.squeeze(train_set_y[:, index])].decode("utf-8") +  "' picture.")
# 显示plt（只有出现了plt.show()才会显示）
plt.show()

# 查找以下各项的值==================================================================================================
# 训练集样本数量
m_train = train_set_x_orig.shape[0]
# 测试集样本数量
m_test = test_set_x_orig.shape[0]
# 训练图像的高度=训练图像的宽度
num_px = train_set_x_orig.shape[1]

print("训练集样本数: m_train = " + str(m_train))
print("测试集样本数: m_test = " + str(m_test))
print("每个图像的高度/宽度: num_px = " + str(num_px))
print("每个图像的大小: (" + str(num_px) + "," + str(num_px) + ",3)")
print ("train_set_x shape: " + str(train_set_x_orig.shape))
print ("train_set_y shape: " + str(train_set_y.shape))
print ("test_set_x shape: " + str(test_set_x_orig.shape))
print ("test_set_y shape: " + str(test_set_y.shape))

# 重塑训练集与测试集样本的形状======================================================================================
# 重塑训练和测试数据集，以便将大小（num_px，num_px，3）的图像展平为单个形状的向量(num_px  num_px  3, 1)。
train_set_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T
test_set_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T
print ("train_set_x_flatten shape: " + str(train_set_x_flatten.shape))
print ("train_set_y shape: " + str(train_set_y.shape))
print ("test_set_x_flatten shape: " + str(test_set_x_flatten.shape))
print ("test_set_y shape: " + str(test_set_y.shape))
print ("检查重塑后的形状: " + str(train_set_x_flatten[0:5,0]))

# 数据标准化:这意味着你要从每个示例中减去整个numpy数组的均值，然后除以整个numpy数组的标准差。但是图片数据集则更为简单方便，并且只要将数据集的每一行除以255（像素通道的最大值），效果也差不多。
train_set_x = train_set_x_flatten/255.
test_set_x = test_set_x_flatten/255.


# 构建算法的各个部分=====================================================================================================

# 1，构建辅助函数(实现sigmoid)============================================================================================
def sigmoid(z):
    """
    计算z的sigmoid。    
    参数：
        z -- 任何大小的标量或numpy数组
    返回：
        # s--sigmoid（z） 
    """
    s = 1/(1 + np.exp(-z))
    return s

print("sigmoid([0,2])= " + str(sigmoid(np.array([0,2]))))

# 初始化参数===============================================================================================================
def initialize_with_zeros(dim):
    '''
    此函数为w创建一个形状为零（dim，1）的矢量，并将b初始化为0。

    参数：
    dim-我们想要的w向量的大小（在这种情况下为参数个数）

    返回值：
    w-形状的初始向量（dim，1）
    b-初始化标量（对应于偏差）
    '''
    w = np.zeros((dim,1))
    b = 0

    assert(w.shape == (dim,1))
    assert(isinstance(b,float) or isinstance(b,int))

    return w,b

# 验证
dim = 2
w, b = initialize_with_zeros(dim)
print ("w = " + str(w))
print ("b = " + str(b))

# 向前和向后传播实现函数propagate（）来计算损失函数及其梯度。================================================================
def propagate(w, b, X, Y):
    """
    实现上述传播的成本函数及其梯度。

    参数：
    W--权重，大小的数字数组(num_px*num_px*3，1)。
    B--偏向，标量。
    X--大小数据(num_px*num_px*3，示例数)。
    Y--大小为(1，示例数)的true“label”向量(如果不是cat，则包含0，如果是cat，则包含1)。

    返回：
    Logistic回归的成本--负对数似然成本。
    Dw--损耗相对于w的梯度，因此形状与w相同。
    Db--损耗相对于b的梯度，因此形状与b相同。

    小贴士：
    -为传播一步一步地编写代码。Np.log()、np.dot()
    """
    m = X.shape[1]

    ##正向传播(从X到COST)。 
    A = sigmoid(np.dot(w.T , X) + b)
    cost = -1/m * np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A))

    ##向后传播（查找梯度）.
    dw = 1/m * np.dot(X, (A - Y).T)
    db = 1/m * np.sum(A - Y)

    assert(dw.shape == w.shape)
    assert(db.dtype == float)
    ##squeeze 函数：从数组的形状中删除单维度条目，即把shape中为1的维度去掉
    cost = np.squeeze(cost)
    assert(cost.shape ==())

    grads = {"dw":dw,
            "db":db}
    return grads, cost

# 验证
w, b, X, Y = np.array([[1],[2]]), 2, np.array([[1,2],[3,4]]), np.array([[1,0]])
grads, cost = propagate(w, b, X, Y)
print ("dw = " + str(grads["dw"]))
print ("db = " + str(grads["db"]))
print ("cost = " + str(cost))

# 优化函数======================================================================================
def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
    """
    参数：
    w-权重，一个大小为numpy的数组（num_px * num_px * 3，1）
    b-偏差，标量
    X-形状数据（num_px * num_px * 3，示例数）
    Y-形状（1，示例数）的真实“标签”向量（如果非cat，则包含0；如果非cat，则包含1）
    num_iterations-优化循环的迭代次数
    learning_rate-梯度下降更新规则的学习率
    print_cost-真，每100步打印一次损失
    
    返回值：
    params-包含权重w和偏向b的字典
    grads-包含权重梯度和相对于成本函数的偏差的字典
    成本-优化过程中计算出的所有成本的列表，将用于绘制学习曲线。
    
    尖端：
    基本上，您需要写下两个步骤并进行迭代：
        1）计算当前参数的成本和梯度。使用property（）。
        2）使用梯度下降规则为w和b更新参数。
    """
    costs = []

    for i in range(num_iterations):
        # 成本和梯度计算
        grads, cost = propagate(w, b, X, Y)
        # 从梯度中检索导数
        dw = grads["dw"]
        db = grads["db"]

        # 更新参数
        w = w - learning_rate * dw
        b = b - learning_rate * db

        # 记录损失
        if i % 100 == 0:
            costs.append(cost)

        # 每100个训练样本输出一次损失
        if print_cost and i % 100 == 0:
            print("迭代后损失 %i: %f" %(i, cost))

    params = {"w": w,
                "b": b}

    grads = {"dw": dw,
                "db": db}

    return params, grads, costs

# 验证
params, grads, costs = optimize(w, b, X, Y, num_iterations= 100, learning_rate = 0.009, print_cost = False)

print ("w = " + str(params["w"]))
print ("b = " + str(params["b"]))
print ("dw = " + str(grads["dw"]))
print ("db = " + str(grads["db"]))
print(costs)

# 使用w和b来预测数据集X的标签，实现predict（）函数。================================================================
def predict(w, b, X):
    """
    使用学习的逻辑回归参数(w, b)预测标签是0还是1

    参数:
    w——weights，一个大小(num_px * num_px * 3,1)的numpy数组
    b——偏差，一个标量
    X——大小数据(num_px * num_px * 3，示例数)

    返回:
    y_predict——一个numpy数组(向量)，包含X中示例的所有预测(0/1)
    """
    m = X.shape[1]
    Y_predict = np.zeros((1, m))
    w = w.reshape(X.shape[0], 1)

    # 计算向量A来预测猫出现在图片上的概率
    A = sigmoid(np.dot(w.T, X) + b)

    for i in range(A.shape[1]):

        # 将概率A[0,i]转换为实际预测p[0,i]
        if A[0, i] <= 0.5:
            Y_predict[0, i] = 0
        else:
            Y_predict[0, i] = 1

    assert(Y_predict.shape == (1, m))

    return Y_predict

# 验证
print ("predictions = " + str(predict(w, b, X)))

# 实现整体模型========================================================================
def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate  = 0.5, print_cost = False):
    """
    通过调用前面实现的函数来构建逻辑回归模型

    参数:
    X_train——由形状的numpy数组表示的训练集(num_px * num_px * 3, m_train)
    Y_train——由形状(1,m_train)的numpy数组(向量)表示的训练标签
    X_test——由形状的numpy数组表示的测试集(num_px * num_px * 3, m_test)
    Y_test——由形状(1,m_test)的numpy数组(向量)表示的测试标签
    num_iterations——超参数，表示优化参数的迭代次数
    learning_rate——超参数，表示优化()更新规则中使用的学习速率。
    print_cost——设置为true将打印每100次迭代的开销

    返回:
    d——包含模型信息的字典。
    """
    # 用0初始化参数
    w, b = initialize_with_zeros(X_train.shape[0])

    # 梯度下降法
    parameters, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate, print_cost)

    # 从字典“参数”中检索参数w和b
    w = parameters["w"]
    b = parameters["b"]

    #预测训练/测试集的样本
    Y_prediction_test = predict(w, b, X_test)
    Y_prediction_train = predict(w, b, X_train)


    #打印训练/测试错误
    print("训练精度: {} %".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))
    print("测试精度: {} %".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))


    d = {"costs": costs,
        "Y_prediction_test": Y_prediction_test,
        "Y_prediction_train" : Y_prediction_train,
        "w" : w,
        "b" : b,
        "learning_rate" : learning_rate,
        "num_iterations": num_iterations}

    return d
# 验证
d = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 2000, learning_rate = 0.005, print_cost = True)

#图片例子
index = 20
plt.imshow(test_set_x[:,index].reshape((num_px, num_px, 3)))
print ("y = " + str(test_set_y[0,index]) + ", 你预测这是一个 \"" + classes[int(d["Y_prediction_test"][0,index])].decode("utf-8") +  "\" 图片.")
plt.show()

# 绘制学习曲线
costs = np.squeeze(d['costs'])
plt.plot(costs)
plt.ylabel('损失')
plt.xlabel('迭代次数s (百)')
plt.title("学习率 =" + str(d["learning_rate"]))
plt.show()

# 改变学习率
learning_rates = [0.01, 0.001, 0.0001]
models = {}
for i in learning_rates:
    print ("学习率为 : " + str(i))
    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)
    print ('\n' + "-------------------------------------------------------" + '\n')

for i in learning_rates:
    plt.plot(np.squeeze(models[str(i)]["costs"]), label= str(models[str(i)]["learning_rate"]))

plt.ylabel('cost')
plt.xlabel('iterations')

legend = plt.legend(loc='upper center', shadow=True)
frame = legend.get_frame()
frame.set_facecolor('0.90')
plt.show()